home *** CD-ROM | disk | FTP | other *** search
/ Motor Sport Digital Archive Collection 1960s / Motor Sport Digital Archive Collection 1960s.iso / main.swf / scripts / mx / effects / EffectInstance.as < prev    next >
Encoding:
Text File  |  2008-05-21  |  9.8 KB  |  356 lines
  1. package mx.effects
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.EventDispatcher;
  5.    import flash.events.TimerEvent;
  6.    import flash.utils.Timer;
  7.    import flash.utils.getQualifiedClassName;
  8.    import flash.utils.getTimer;
  9.    import mx.core.IUIComponent;
  10.    import mx.core.mx_internal;
  11.    import mx.effects.effectClasses.PropertyChanges;
  12.    import mx.events.EffectEvent;
  13.    import mx.events.FlexEvent;
  14.    
  15.    use namespace mx_internal;
  16.    
  17.    public class EffectInstance extends EventDispatcher implements IEffectInstance
  18.    {
  19.       mx_internal static const VERSION:String = "2.0.1.0";
  20.       
  21.       private var delayStartTime:Number = 0;
  22.       
  23.       private var playCount:int = 0;
  24.       
  25.       mx_internal var stopRepeat:Boolean = false;
  26.       
  27.       private var _repeatCount:int;
  28.       
  29.       private var _suspendBackgroundProcessing:Boolean = false;
  30.       
  31.       mx_internal var delayTimer:Timer;
  32.       
  33.       private var _triggerEvent:Event;
  34.       
  35.       mx_internal var parentCompositeEffectInstance:EffectInstance;
  36.       
  37.       mx_internal var durationExplicitlySet:Boolean = false;
  38.       
  39.       private var _effect:Effect;
  40.       
  41.       private var _target:Object;
  42.       
  43.       mx_internal var hideOnEffectEnd:Boolean = false;
  44.       
  45.       private var _startDelay:int = 0;
  46.       
  47.       private var delayElapsedTime:Number = 0;
  48.       
  49.       private var _repeatDelay:int = 0;
  50.       
  51.       private var _propertyChanges:PropertyChanges;
  52.       
  53.       private var _duration:Number = 500;
  54.       
  55.       private var _playReversed:Boolean;
  56.       
  57.       public function EffectInstance(param1:Object)
  58.       {
  59.          delayStartTime = 0;
  60.          delayElapsedTime = 0;
  61.          mx_internal::durationExplicitlySet = false;
  62.          mx_internal::hideOnEffectEnd = false;
  63.          playCount = 0;
  64.          mx_internal::stopRepeat = false;
  65.          _duration = 500;
  66.          _repeatDelay = 0;
  67.          _startDelay = 0;
  68.          _suspendBackgroundProcessing = false;
  69.          super();
  70.          this.target = param1;
  71.       }
  72.       
  73.       public function get playheadTime() : Number
  74.       {
  75.          return Math.max(playCount - 1,0) * duration + Math.max(playCount - 2,0) * repeatDelay + (mx_internal::playReversed ? 0 : startDelay);
  76.       }
  77.       
  78.       public function finishEffect() : void
  79.       {
  80.          playCount = 0;
  81.          dispatchEvent(new EffectEvent(EffectEvent.EFFECT_END,false,false,this));
  82.          if(target)
  83.          {
  84.             target.dispatchEvent(new EffectEvent(EffectEvent.EFFECT_END,false,false,this));
  85.          }
  86.          if(target is IUIComponent)
  87.          {
  88.             Object(target).effectFinished(this);
  89.          }
  90.       }
  91.       
  92.       public function finishRepeat() : void
  93.       {
  94.          if(!mx_internal::stopRepeat && playCount != 0 && (playCount < repeatCount || repeatCount == 0))
  95.          {
  96.             if(repeatDelay > 0)
  97.             {
  98.                mx_internal::delayTimer = new Timer(repeatDelay,1);
  99.                delayStartTime = getTimer();
  100.                mx_internal::delayTimer.addEventListener(TimerEvent.TIMER,delayTimerHandler);
  101.                mx_internal::delayTimer.start();
  102.             }
  103.             else
  104.             {
  105.                play();
  106.             }
  107.          }
  108.          else
  109.          {
  110.             finishEffect();
  111.          }
  112.       }
  113.       
  114.       mx_internal function get playReversed() : Boolean
  115.       {
  116.          return _playReversed;
  117.       }
  118.       
  119.       public function set effect(param1:Effect) : void
  120.       {
  121.          _effect = param1;
  122.       }
  123.       
  124.       public function get className() : String
  125.       {
  126.          var _loc1_:String = null;
  127.          var _loc2_:int = 0;
  128.          _loc1_ = getQualifiedClassName(this);
  129.          _loc2_ = int(_loc1_.indexOf("::"));
  130.          if(_loc2_ != -1)
  131.          {
  132.             _loc1_ = _loc1_.substr(_loc2_ + 2);
  133.          }
  134.          return _loc1_;
  135.       }
  136.       
  137.       public function set duration(param1:Number) : void
  138.       {
  139.          mx_internal::durationExplicitlySet = true;
  140.          _duration = param1;
  141.       }
  142.       
  143.       mx_internal function set playReversed(param1:Boolean) : void
  144.       {
  145.          _playReversed = param1;
  146.       }
  147.       
  148.       public function resume() : void
  149.       {
  150.          if(mx_internal::delayTimer && !mx_internal::delayTimer.running && !isNaN(delayElapsedTime))
  151.          {
  152.             mx_internal::delayTimer.delay = !mx_internal::playReversed ? mx_internal::delayTimer.delay - delayElapsedTime : delayElapsedTime;
  153.             mx_internal::delayTimer.start();
  154.          }
  155.       }
  156.       
  157.       public function get propertyChanges() : PropertyChanges
  158.       {
  159.          return _propertyChanges;
  160.       }
  161.       
  162.       public function set target(param1:Object) : void
  163.       {
  164.          _target = param1;
  165.       }
  166.       
  167.       public function get repeatCount() : int
  168.       {
  169.          return _repeatCount;
  170.       }
  171.       
  172.       mx_internal function playWithNoDuration() : void
  173.       {
  174.          duration = 0;
  175.          repeatCount = 1;
  176.          repeatDelay = 0;
  177.          startDelay = 0;
  178.          startEffect();
  179.       }
  180.       
  181.       public function get startDelay() : int
  182.       {
  183.          return _startDelay;
  184.       }
  185.       
  186.       mx_internal function get actualDuration() : Number
  187.       {
  188.          var _loc1_:Number = NaN;
  189.          _loc1_ = NaN;
  190.          if(repeatCount > 0)
  191.          {
  192.             _loc1_ = duration * repeatCount + (repeatDelay * repeatCount - 1) + startDelay;
  193.          }
  194.          return _loc1_;
  195.       }
  196.       
  197.       public function get suspendBackgroundProcessing() : Boolean
  198.       {
  199.          return _suspendBackgroundProcessing;
  200.       }
  201.       
  202.       public function play() : void
  203.       {
  204.          ++playCount;
  205.          dispatchEvent(new EffectEvent(EffectEvent.EFFECT_START,false,false,this));
  206.          if(target)
  207.          {
  208.             target.dispatchEvent(new EffectEvent(EffectEvent.EFFECT_START,false,false,this));
  209.          }
  210.       }
  211.       
  212.       public function set repeatDelay(param1:int) : void
  213.       {
  214.          _repeatDelay = param1;
  215.       }
  216.       
  217.       public function set propertyChanges(param1:PropertyChanges) : void
  218.       {
  219.          _propertyChanges = param1;
  220.       }
  221.       
  222.       mx_internal function eventHandler(param1:Event) : void
  223.       {
  224.          if(param1.type == FlexEvent.SHOW && mx_internal::hideOnEffectEnd == true)
  225.          {
  226.             mx_internal::hideOnEffectEnd = false;
  227.             param1.target.removeEventListener(FlexEvent.SHOW,mx_internal::eventHandler);
  228.          }
  229.       }
  230.       
  231.       public function set repeatCount(param1:int) : void
  232.       {
  233.          _repeatCount = param1;
  234.       }
  235.       
  236.       private function delayTimerHandler(param1:TimerEvent) : void
  237.       {
  238.          mx_internal::delayTimer.reset();
  239.          delayStartTime = NaN;
  240.          delayElapsedTime = NaN;
  241.          play();
  242.       }
  243.       
  244.       public function set suspendBackgroundProcessing(param1:Boolean) : void
  245.       {
  246.          _suspendBackgroundProcessing = param1;
  247.       }
  248.       
  249.       public function set triggerEvent(param1:Event) : void
  250.       {
  251.          _triggerEvent = param1;
  252.       }
  253.       
  254.       public function set startDelay(param1:int) : void
  255.       {
  256.          _startDelay = param1;
  257.       }
  258.       
  259.       public function get effect() : Effect
  260.       {
  261.          return _effect;
  262.       }
  263.       
  264.       public function get duration() : Number
  265.       {
  266.          if(!mx_internal::durationExplicitlySet && Boolean(mx_internal::parentCompositeEffectInstance))
  267.          {
  268.             return mx_internal::parentCompositeEffectInstance.duration;
  269.          }
  270.          return _duration;
  271.       }
  272.       
  273.       public function get target() : Object
  274.       {
  275.          return _target;
  276.       }
  277.       
  278.       public function startEffect() : void
  279.       {
  280.          if(target is IUIComponent)
  281.          {
  282.             Object(target).effectStarted(this);
  283.             Object(target).drawFocus(false);
  284.          }
  285.          if(startDelay > 0 && !mx_internal::playReversed)
  286.          {
  287.             mx_internal::delayTimer = new Timer(startDelay,1);
  288.             delayStartTime = getTimer();
  289.             mx_internal::delayTimer.addEventListener(TimerEvent.TIMER,delayTimerHandler);
  290.             mx_internal::delayTimer.start();
  291.          }
  292.          else
  293.          {
  294.             play();
  295.          }
  296.       }
  297.       
  298.       public function get repeatDelay() : int
  299.       {
  300.          return _repeatDelay;
  301.       }
  302.       
  303.       public function initEffect(param1:Event) : void
  304.       {
  305.          triggerEvent = param1;
  306.          switch(param1.type)
  307.          {
  308.             case "resizeStart":
  309.             case "resizeEnd":
  310.                if(!mx_internal::durationExplicitlySet)
  311.                {
  312.                   duration = 250;
  313.                }
  314.                break;
  315.             case FlexEvent.HIDE:
  316.                target.setVisible(true,true);
  317.                mx_internal::hideOnEffectEnd = true;
  318.                target.addEventListener(FlexEvent.SHOW,mx_internal::eventHandler);
  319.          }
  320.       }
  321.       
  322.       public function get triggerEvent() : Event
  323.       {
  324.          return _triggerEvent;
  325.       }
  326.       
  327.       public function end() : void
  328.       {
  329.          if(mx_internal::delayTimer)
  330.          {
  331.             mx_internal::delayTimer.reset();
  332.          }
  333.          mx_internal::stopRepeat = true;
  334.          finishEffect();
  335.       }
  336.       
  337.       public function reverse() : void
  338.       {
  339.          if(repeatCount > 0)
  340.          {
  341.             playCount = repeatCount - playCount + 1;
  342.          }
  343.       }
  344.       
  345.       public function pause() : void
  346.       {
  347.          if(mx_internal::delayTimer && mx_internal::delayTimer.running && !isNaN(delayStartTime))
  348.          {
  349.             mx_internal::delayTimer.stop();
  350.             delayElapsedTime = getTimer() - delayStartTime;
  351.          }
  352.       }
  353.    }
  354. }
  355.  
  356.